home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet internetowy / Rozne / HTTrack 3.40-2 / httrack-3.40-2.exe / {app} / src / proxy / proxystrings.h < prev    next >
C/C++ Source or Header  |  2005-09-18  |  4KB  |  154 lines
  1. /* ------------------------------------------------------------ */
  2. /*
  3. HTTrack Website Copier, Offline Browser for Windows and Unix
  4. Copyright (C) Xavier Roche and other contributors
  5.  
  6. This program is free software; you can redistribute it and/or
  7. modify it under the terms of the GNU General Public License
  8. as published by the Free Software Foundation; either version 2
  9. of the License, or any later version.
  10.  
  11. This program is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with this program; if not, write to the Free Software
  18. Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  19.  
  20. Please visit our Website: http://www.httrack.com
  21. */
  22.  
  23.  
  24. /* ------------------------------------------------------------ */
  25. /* File: Strings                                                */
  26. /* Author: Xavier Roche                                         */
  27. /* ------------------------------------------------------------ */
  28.  
  29. // Strings a bit safer than static buffers
  30.  
  31. #ifndef HTS_STRINGS_DEFSTATIC
  32. #define HTS_STRINGS_DEFSTATIC 
  33.  
  34. typedef struct String {
  35.   char* buff;
  36.   int len;
  37.   int capa;
  38. } String;
  39.  
  40. #define STRING_EMPTY {NULL, 0, 0}
  41. #define STRING_BLK_SIZE 256
  42. #define StringBuff(blk) ((blk).buff)
  43. #define StringLength(blk) ((blk).len)
  44. #define StringCapacity(blk) ((blk).capa)
  45. #define StringRoom(blk, size) do { \
  46.   if ((blk).len + (int)(size) + 1 > (blk).capa) { \
  47.     (blk).capa = ((blk).len + (size) + 1) * 2; \
  48.     (blk).buff = (char*) realloc((blk).buff, (blk).capa); \
  49.   } \
  50. } while(0)
  51. #define StringBuffN(blk, size) StringBuffN_(&(blk), size) 
  52. static char* StringBuffN_(String* blk, int size) {
  53.   StringRoom(*blk, (blk->len) + size);
  54.   return StringBuff(*blk);
  55. }
  56. #define StringClear(blk) do { \
  57.   StringRoom(blk, 0); \
  58.   (blk).buff[0] = '\0'; \
  59.   (blk).len = 0; \
  60. } while(0)
  61. #define StringFree(blk) do { \
  62.   if ((blk).buff != NULL) { \
  63.     free((blk).buff); \
  64.     (blk).buff = NULL; \
  65.   } \
  66.   (blk).capa = 0; \
  67.   (blk).len = 0; \
  68. } while(0)
  69. #define StringMemcat(blk, str, size) do { \
  70.   StringRoom(blk, size); \
  71.   if ((int)(size) > 0) { \
  72.     memcpy((blk).buff + (blk).len, (str), (size)); \
  73.     (blk).len += (size); \
  74.   } \
  75.   *((blk).buff + (blk).len) = '\0'; \
  76. } while(0)
  77. #define StringAddchar(blk, c) do { \
  78.   char __c = (c); \
  79.   StringMemcat(blk, &__c, 1); \
  80. } while(0)
  81. static void* StringAcquire(String* blk) {
  82.   void* buff = blk->buff;
  83.   blk->buff = NULL;
  84.   blk->capa = 0;
  85.   blk->len = 0;
  86.   return buff;
  87. }
  88. static StringAttach(String* blk, char** str) {
  89.     StringFree(*blk);
  90.     if (str != NULL && *str != NULL) {
  91.         blk->buff = *str;
  92.         blk->capa = (int)strlen(blk->buff);
  93.         blk->len = blk->capa;
  94.         *str = NULL;
  95.     }
  96. }
  97. #define StringStrcat(blk, str) StringMemcat(blk, str, ((str) != NULL) ? (int)strlen(str) : 0)
  98. #define StringStrcpy(blk, str) do { \
  99.   StringClear(blk); \
  100.   StringStrcat(blk, str); \
  101. } while(0)
  102.  
  103. /* Tools */
  104.  
  105. static int ehexh(char c) {
  106.   if ((c>='0') && (c<='9')) return c-'0';
  107.   if ((c>='a') && (c<='f')) c-=('a'-'A');
  108.   if ((c>='A') && (c<='F')) return (c-'A'+10);
  109.   return 0;
  110. }
  111.  
  112. static int ehex(const char* s) {
  113.   return 16*ehexh(*s)+ehexh(*(s+1));
  114. }
  115.  
  116. static void unescapehttp(const char* s, String* tempo) {
  117.   int i;
  118.   for (i = 0; s[i] != '\0' ; i++) {
  119.     if (s[i]=='%' && s[i+1]=='%') {
  120.       i++;
  121.       StringAddchar(*tempo, '%');
  122.     } else if (s[i]=='%') {
  123.       char hc;
  124.       i++;
  125.       hc = (char) ehex(s+i);
  126.       StringAddchar(*tempo, (char) hc);
  127.       i++;    // sauter 2 caractΦres finalement
  128.     }
  129.     else if (s[i]=='+') {
  130.       StringAddchar(*tempo, ' ');
  131.     }
  132.     else
  133.       StringAddchar(*tempo, s[i]);
  134.   }
  135. }
  136.  
  137. static void escapexml(const char* s, String* tempo) {
  138.   int i;
  139.   for (i=0 ; s[i] != '\0' ; i++) {
  140.     if (s[i] == '&')
  141.       StringStrcat(*tempo, "&");
  142.         else if (s[i] == '<')
  143.       StringStrcat(*tempo, "<");
  144.         else if (s[i] == '>')
  145.       StringStrcat(*tempo, ">");
  146.         else if (s[i] == '\"')
  147.       StringStrcat(*tempo, """);
  148.     else
  149.       StringAddchar(*tempo, s[i]);
  150.   }
  151. }
  152.  
  153. #endif
  154.